/*
 * file_manage.h
 *
 *  Created on: 06/10/2013
 *      Author: AXL
 */

#ifndef FILE_MANAGE_H_
#define FILE_MANAGE_H_

#define STR_EXPAND(tok) #tok
#define STR(tok) STR_EXPAND(tok)	/* I.E: STR(BUF_LEN) ---> "100" */

#define BUF_LEN 100		/* longitud de buffer */

#define ERROR -1

#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include "Cola.h"
#include "var_array.h"
#include "validaciones.h"
#include "archivo_versionado.h"
#include "utils.h"

typedef struct
{
	int x;
	int y;
} tuple_t;

typedef struct
{
	int index;
	char* text;
} line_t;

/**
 * Indica si el archivo en la ruta `filename` existe.
 * RETURN 	0	el arhivo no existe.
 */
int fileExists( const char* filename );

/**
 * Crea una copia exacta de un archivo `source` en `copy`.
 * Si el archivo en `copy` no existe, lo crea.
 * RETURN	ERROR	no se realizo la copia correctamente.
 * 				0	copia realizada con exito.
 */
int fileCopy( const char* source, const char* copy );

/**
 * Crea un archivo en la ruta `path`.
 * RETURN	ERROR	no se pudo crear el archivo.
 */
int createFile( const char* path );

/**
 * Lee una linea de un archivo `file`.
 * PRE: 	`file` es un puntero a archivo correctamente abierto.
 * POST:	El usuario se debe encargar de liberar la memoria alocada devuelta.
 * 			`status` en -1 significa que no leyo nada y devuelve string vacia.
 * RETURN 	char*	puntero a la cadena leida.
 * 			NULL	no se pudo leer la linea.
 */
char* getLine( FILE* file, int* status );

/**
 * Posiciona el puntero de lectura del archivo en la siguiente linea no vacia.
 * PRE:		`file` es un puntero a archivo correctamente abierto.
 * RETURN		0	ejecucion correcta.
 * 			ERROR	ocurrio algun error.
 */
int skipLine( FILE* file );

/**
 * Lee una 'string' de `file` y valida que sea una fecha (formato ISO 8601).
 * PRE:		`file` apunta a un archivo correctamente abierto.
 * POST:	De resultar en una lectura correcta, el usuario debe liberar la
 * 			memoria de a cadena devuelta.
 * RETURN	NULL 	el valor leido en `file` no es una fecha valida o hubo
 * 					un error.
 * 			char*	puntero a una cadena con la fecha.
 */
char* readDate( FILE* file );

/**
 * Guarda el archivo `file` desde la posicion actual hasta el final linea por
 * linea, gurdandolas en `list` (los '\n' NO SE GURDAN).
 * PRE:		`list` fue creada y `file` abierto.
 * POST:	La memoria de las lineas leidas debe ser liberada por el usuario
 * 			(ver fileListDestroy(...)).
 * RETURN	ERROR	fallo la carga de datos y la lista queda vacia.
 */
int fileAsList( TListaSimple* list, const char* path );

/**
 * Libera la memoria de todos los elementos de `list` y la vacia.
 * PRE:		`list` fue creada para contener punteros a char.
 * POST:	`list` vacia y memoria liberada.
 */
void fileListDestroy( TListaSimple* list );

/**
 * Carga las `line_t` de `src` en `dest` salteando las que tienen un `index`
 * igual al de algun elemeto de `matches`.
 * PRE:		`matches` y `src` tienen los corrientes posicionados desde donde
 * 			se quiere comenzar el intrcambio.
 * RETURN	ERROR	no habia memoria suficiente.
 */
int insertInto( TCola* dest, TListaSimple* matches, TListaSimple* src, int end );

/**
 * Guarda en `matches` las lineas iguales entre `a` y `b` en las listas.
 * PRE:		`match_a/b` creada para almacenar `int`.
 * 			`a` y `b` listas con `line_t`.
 * 			La comapracion se hace desde las lineas donde esta el corriente en
 * 			cada lista.
 * RETURN	ERROR	no se obtuvieron las diferencias y `match_a/b` queda vacia.
 */
int getMatches( TListaSimple* match_a, TListaSimple* match_b, TListaSimple* a,
		TListaSimple* b );
/**
 * Guarda un archivo de texto en un V_Array `array` en forma de `line_t` con el
 * contenido de cada una de sus lineas.
 * PRE:		array creado para contener `line_t`, ruta es la ruta a un archivo.
 * POST:	cada posicion del array corresponde a una linea del archivo.
 * 			Si hubo algun error el array queda vacio.
 * RETURN 	ERROR 	no se pudo completar la escritura.
 */
int fileToArray( const char* filename, V_Array* array );

/**
 * Vacia y destruye un V_Array cargado con fileToArray().
 * PRE:		el array contiene punteros a string.
 * POST:	array destruido y memoria de strings liberada.
 */
void clearFileArray( V_Array* array );

#endif /* FILE_MANAGE_H_ */
